{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Siamese Network Architecture using MNIST Dataset\n",
    "\n",
    "If you recall Chapter 2: Metrics Based Methods, in book, Siamese Networks looks something like this:\n",
    "\n",
    "![practical_gan_3.gif](Images/Siamese.gif)\n",
    "\n",
    "\n",
    "In this tutorial, we will build a Siamese Network Architecture for One-Shot Learning using Pytorch and other python libraries. \n",
    "we will building modules step by step:\n",
    "\n",
    "1. Data Preprocessing: Creating Pairs.\n",
    "\n",
    "2. Create a Siamese Network Architecture.\n",
    "\n",
    "3. Train it using Small MNIST dataset. \n",
    "\n",
    "4. Visualize Embeddings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step1: Lets first import all libraries needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- encoding: utf-8 -*-\n",
    "import argparse\n",
    "import torch\n",
    "import torchvision.datasets as dsets\n",
    "import random\n",
    "import numpy as np\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.autograd import Variable\n",
    "from torchvision import transforms\n",
    "import pickle\n",
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Preprocessing\n",
    "As we learned in theory part of Siamese Network, that as part of data preprocessing we need to create pairs.\n",
    "1. 1 pair-> similar; y=0\n",
    "2. 1 pair-> dissimilar; y=1\n",
    "\n",
    "![Screen%20Shot%202019-06-17%20at%2010.02.52%20AM.png](Images/example.png)\n",
    "\n",
    "Note: We are using contrastive loss function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step2: To preporcess data, and create iterator for model, first create a Dataset Loader Class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dataset(object):\n",
    "    '''\n",
    "    Class Dataset:\n",
    "    Input: numpy values\n",
    "    Output: torch variables.\n",
    "    '''\n",
    "    def __init__(self, x0, x1, label):\n",
    "        self.size = label.shape[0] \n",
    "        self.x0 = torch.from_numpy(x0)\n",
    "        self.x1 = torch.from_numpy(x1)\n",
    "        self.label = torch.from_numpy(label)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return (self.x0[index],\n",
    "                self.x1[index],\n",
    "                self.label[index])\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Before creating an iterator, lets create pairs, and preprocess images in them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_pairs(data, digit_indices):\n",
    "    x0_data = []\n",
    "    x1_data = []\n",
    "    label = []\n",
    "    n = min([len(digit_indices[d]) for d in range(10)]) - 1\n",
    "    for d in range(10): # for MNIST dataset: as we have 10 digits\n",
    "        for i in range(n):\n",
    "            z1, z2 = digit_indices[d][i], digit_indices[d][i + 1]\n",
    "            x0_data.append(data[z1] / 255.) # Image Preprocessing Step\n",
    "            x1_data.append(data[z2] / 255.) # Image Preprocessing Step\n",
    "            label.append(1)\n",
    "            inc = random.randrange(1, 10)\n",
    "            dn = (d + inc) % 10\n",
    "            z1, z2 = digit_indices[d][i], digit_indices[dn][i]\n",
    "            x0_data.append(data[z1] / 255.) # Image Preprocessing Step\n",
    "            x1_data.append(data[z2] / 255.) # Image Preprocessing Step\n",
    "            label.append(0)\n",
    "\n",
    "    x0_data = np.array(x0_data, dtype=np.float32)\n",
    "    x0_data = x0_data.reshape([-1, 1, 28, 28])\n",
    "    x1_data = np.array(x1_data, dtype=np.float32)\n",
    "    x1_data = x1_data.reshape([-1, 1, 28, 28])\n",
    "    label = np.array(label, dtype=np.int32)\n",
    "    return x0_data, x1_data, label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### create iterator: returns set of given batchsize for training purpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_iterator(data, label, batchsize, shuffle=False):\n",
    "    digit_indices = [np.where(label == i)[0] for i in range(10)]\n",
    "    x0, x1, label = create_pairs(data, digit_indices)\n",
    "    ret = Dataset(x0, x1, label)\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss Function: Contrastive Loss Function "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3: Create Loss Function\n",
    "As we know contrastive loss function consists of 2 parts:\n",
    "![contrastive%20Loss.png](Images/contrastiveLoss.png)\n",
    "\n",
    "1. for similar points: (1-y)*(distance_function)^2\n",
    "2. for dissimilar points: y*{max(0,(m-distance_function^2)}\n",
    "\n",
    "Here Distance Function is taken as euclidean distance, also known as root mean square."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contrastive_loss_function(x0, x1, y, margin=1.0):\n",
    "    # euclidean distance\n",
    "    diff = x0 - x1\n",
    "    dist_sq = torch.sum(torch.pow(diff, 2), 1)\n",
    "    dist = torch.sqrt(dist_sq)\n",
    "    mdist = margin - dist\n",
    "    dist = torch.clamp(mdist, min=0.0)\n",
    "    loss = y * dist_sq + (1 - y) * torch.pow(dist, 2)\n",
    "    loss = torch.sum(loss) / 2.0 / x0.size()[0]\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Siamese Network Architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 4: Creating Siamese Network Architecture\n",
    "For this first lets create a class called SiameseNetwork with 2 functions:\n",
    "###### 1. forward_once: In forward_once pass through all layers and returns the output embeddings \n",
    "###### 2. forward: In forward, call forward_once 2 times for the Input pair given, and returns the embeddings obtained\n",
    "\n",
    "\n",
    "As discussed in theory part of Siamese Network, we share parameters of twins, so we don't need to create explicitly both brances, we can just create one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SiameseNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SiameseNetwork, self).__init__()\n",
    "        self.cnn1 = nn.Sequential(\n",
    "            nn.Conv2d(1, 20, kernel_size=5),\n",
    "            nn.MaxPool2d(2, stride=2),\n",
    "            nn.Conv2d(20, 50, kernel_size=5),\n",
    "            nn.MaxPool2d(2, stride=2))\n",
    "        self.fc1 = nn.Sequential(\n",
    "            nn.Linear(50 * 4 * 4, 500),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(500,10),\n",
    "            nn.Linear(10, 2))\n",
    "        \n",
    "    def forward_once(self, x):\n",
    "        output = self.cnn1(x)\n",
    "        output = output.view(output.size()[0], -1)\n",
    "        output = self.fc1(output)\n",
    "        return output\n",
    "\n",
    "    def forward(self, input1, input2):\n",
    "        output1 = self.forward_once(input1)\n",
    "        output2 = self.forward_once(input2)\n",
    "        return output1, output2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reduce MNIST dataset, choose random '2000' points\n",
    "Setting Batch-Size=128, and importing MNIST dataset\n",
    "\n",
    "You can download MNIST dataset from link\n",
    "\n",
    "*** feel free to modify these parameters and experiment with them !!! ***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "batchsize=128\n",
    "train = dsets.MNIST(root='../data/',train=True,download=True)\n",
    "test = dsets.MNIST(root='../data/',train=False,transform=transforms.Compose([transforms.ToTensor(),]))\n",
    "indices= np.random.choice(len(train.targets.numpy()), 2000, replace=False)\n",
    "indices_test= np.random.choice(len(test.targets.numpy()), 100, replace=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### We created an iterator above, here we will use it to create training and test set iterators. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_iter = create_iterator(train.data.numpy()[indices],train.targets.numpy()[indices],batchsize)\n",
    "test_iter = create_iterator(test.data.numpy()[indices_test],test.targets.numpy()[indices_test],batchsize)\n",
    "\n",
    "# call model\n",
    "model = SiameseNetwork()\n",
    "learning_rate = 0.01 # learning rate for optimization\n",
    "momentum = 0.9 # momentum\n",
    "\n",
    "# Loss and Optimizer\n",
    "criterion = contrastive_loss_function # we will use contrastive loss function as defined above\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate,momentum=momentum)\n",
    "\n",
    "# creating a train loader, and a test loader.\n",
    "train_loader = torch.utils.data.DataLoader(train_iter,batch_size=batchsize, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test,batch_size=batchsize, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's Train our Model !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 5: Train Model for certain number of epochs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 \tLoss: 0.238540\n",
      "Epoch: 1 \tLoss: 0.137685\n",
      "Epoch: 2 \tLoss: 0.128957\n",
      "Epoch: 3 \tLoss: 0.095902\n",
      "Epoch: 4 \tLoss: 0.097862\n",
      "Epoch: 5 \tLoss: 0.097706\n",
      "Epoch: 6 \tLoss: 0.089233\n",
      "Epoch: 7 \tLoss: 0.095264\n",
      "Epoch: 8 \tLoss: 0.065943\n",
      "Epoch: 9 \tLoss: 0.066853\n",
      "Epoch: 10 \tLoss: 0.051547\n",
      "Epoch: 11 \tLoss: 0.060146\n",
      "Epoch: 12 \tLoss: 0.066950\n",
      "Epoch: 13 \tLoss: 0.068492\n",
      "Epoch: 14 \tLoss: 0.052818\n",
      "Epoch: 15 \tLoss: 0.054210\n",
      "Epoch: 16 \tLoss: 0.052535\n",
      "Epoch: 17 \tLoss: 0.038190\n",
      "Epoch: 18 \tLoss: 0.043936\n",
      "Epoch: 19 \tLoss: 0.045972\n",
      "Epoch: 20 \tLoss: 0.041547\n",
      "Epoch: 21 \tLoss: 0.036499\n",
      "Epoch: 22 \tLoss: 0.042290\n",
      "Epoch: 23 \tLoss: 0.029713\n",
      "Epoch: 24 \tLoss: 0.037489\n",
      "Epoch: 25 \tLoss: 0.028232\n",
      "Epoch: 26 \tLoss: 0.037456\n",
      "Epoch: 27 \tLoss: 0.030307\n",
      "Epoch: 28 \tLoss: 0.025705\n",
      "Epoch: 29 \tLoss: 0.028600\n",
      "Epoch: 30 \tLoss: 0.029290\n",
      "Epoch: 31 \tLoss: 0.026971\n",
      "Epoch: 32 \tLoss: 0.028523\n",
      "Epoch: 33 \tLoss: 0.027738\n",
      "Epoch: 34 \tLoss: 0.026742\n",
      "Epoch: 35 \tLoss: 0.019707\n",
      "Epoch: 36 \tLoss: 0.024001\n",
      "Epoch: 37 \tLoss: 0.017403\n",
      "Epoch: 38 \tLoss: 0.018784\n",
      "Epoch: 39 \tLoss: 0.028700\n",
      "Epoch: 40 \tLoss: 0.016271\n",
      "Epoch: 41 \tLoss: 0.018483\n",
      "Epoch: 42 \tLoss: 0.016789\n",
      "Epoch: 43 \tLoss: 0.017989\n",
      "Epoch: 44 \tLoss: 0.017040\n",
      "Epoch: 45 \tLoss: 0.018460\n",
      "Epoch: 46 \tLoss: 0.022482\n",
      "Epoch: 47 \tLoss: 0.016778\n",
      "Epoch: 48 \tLoss: 0.016184\n",
      "Epoch: 49 \tLoss: 0.010879\n",
      "Epoch: 50 \tLoss: 0.012103\n",
      "Epoch: 51 \tLoss: 0.012184\n",
      "Epoch: 52 \tLoss: 0.011131\n",
      "Epoch: 53 \tLoss: 0.015544\n",
      "Epoch: 54 \tLoss: 0.012005\n",
      "Epoch: 55 \tLoss: 0.012611\n",
      "Epoch: 56 \tLoss: 0.010338\n",
      "Epoch: 57 \tLoss: 0.012227\n",
      "Epoch: 58 \tLoss: 0.010408\n",
      "Epoch: 59 \tLoss: 0.011668\n",
      "Epoch: 60 \tLoss: 0.008641\n",
      "Epoch: 61 \tLoss: 0.009807\n",
      "Epoch: 62 \tLoss: 0.009484\n",
      "Epoch: 63 \tLoss: 0.007448\n",
      "Epoch: 64 \tLoss: 0.008115\n",
      "Epoch: 65 \tLoss: 0.010181\n",
      "Epoch: 66 \tLoss: 0.007624\n",
      "Epoch: 67 \tLoss: 0.009213\n",
      "Epoch: 68 \tLoss: 0.007558\n",
      "Epoch: 69 \tLoss: 0.008431\n",
      "Epoch: 70 \tLoss: 0.007009\n",
      "Epoch: 71 \tLoss: 0.007527\n",
      "Epoch: 72 \tLoss: 0.006589\n",
      "Epoch: 73 \tLoss: 0.007696\n",
      "Epoch: 74 \tLoss: 0.010615\n",
      "Epoch: 75 \tLoss: 0.007182\n",
      "Epoch: 76 \tLoss: 0.007662\n",
      "Epoch: 77 \tLoss: 0.005797\n",
      "Epoch: 78 \tLoss: 0.007105\n",
      "Epoch: 79 \tLoss: 0.006079\n",
      "Epoch: 80 \tLoss: 0.005503\n",
      "Epoch: 81 \tLoss: 0.007207\n",
      "Epoch: 82 \tLoss: 0.008390\n",
      "Epoch: 83 \tLoss: 0.005194\n",
      "Epoch: 84 \tLoss: 0.006607\n",
      "Epoch: 85 \tLoss: 0.005184\n",
      "Epoch: 86 \tLoss: 0.005152\n",
      "Epoch: 87 \tLoss: 0.004121\n",
      "Epoch: 88 \tLoss: 0.003870\n",
      "Epoch: 89 \tLoss: 0.005093\n",
      "Epoch: 90 \tLoss: 0.003882\n",
      "Epoch: 91 \tLoss: 0.004499\n",
      "Epoch: 92 \tLoss: 0.004751\n",
      "Epoch: 93 \tLoss: 0.003857\n",
      "Epoch: 94 \tLoss: 0.004013\n",
      "Epoch: 95 \tLoss: 0.004318\n",
      "Epoch: 96 \tLoss: 0.004413\n",
      "Epoch: 97 \tLoss: 0.003426\n",
      "Epoch: 98 \tLoss: 0.002309\n",
      "Epoch: 99 \tLoss: 0.003485\n"
     ]
    }
   ],
   "source": [
    "train_loss = []\n",
    "epochs =100\n",
    "for epoch in range(epochs):\n",
    "    for batch_idx, (x0, x1, labels) in enumerate(train_loader):\n",
    "        labels = labels.float()\n",
    "        x0, x1, labels = Variable(x0), Variable(x1), Variable(labels)\n",
    "        output1, output2 = model(x0, x1)\n",
    "        loss = criterion(output1, output2, labels)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        train_loss.append(loss.item())\n",
    "        if batch_idx % batchsize == 0:\n",
    "            print('Epoch: {} \\tLoss: {:.6f}'.format(epoch, loss.item()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's Visualize our Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step5: Lets Create all functions for plotting embeddings and loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_loss(train_loss,name=\"train_loss.png\"):\n",
    "    plt.plot(train_loss, label=\"train loss\")\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mnist(numpy_all, numpy_labels,name=\"./embeddings_plot.png\"):\n",
    "        c = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff',\n",
    "             '#ff00ff', '#990000', '#999900', '#009900', '#009999']\n",
    "\n",
    "        for i in range(10):\n",
    "            f = numpy_all[np.where(numpy_labels == i)]\n",
    "            plt.plot(f[:, 0], f[:, 1], '.', c=c[i])\n",
    "        plt.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])\n",
    "        plt.savefig(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Loss Function Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_loss(train_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting test-set Embeddings of MNIST dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_model(model):\n",
    "        model.eval()\n",
    "        all_ = []\n",
    "        all_labels = []\n",
    "        with torch.no_grad():\n",
    "            for batch_idx, (x, labels) in enumerate(test_loader):\n",
    "                x, labels = Variable(x), Variable(labels)\n",
    "                output = model.forward_once(x)\n",
    "                all_.extend(output.data.cpu().numpy().tolist())\n",
    "                all_labels.extend(labels.data.cpu().numpy().tolist())\n",
    "\n",
    "        numpy_all = np.array(all_)\n",
    "        numpy_labels = np.array(all_labels)\n",
    "        return numpy_all, numpy_labels\n",
    "\n",
    "def testing_plots(model):\n",
    "        dict_pickle={}\n",
    "        numpy_all, numpy_labels = test_model(model)\n",
    "        dict_pickle[\"numpy_all\"]=numpy_all\n",
    "        dict_pickle[\"numpy_labels\"]=numpy_labels\n",
    "        plot_mnist(numpy_all, numpy_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "testing_plots(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In above embeddings Plot, what we can observe is that majority of points are in a cluster, whereas some points are not part of cluster, can be seen as outliers."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
